// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.loan.monthly.balance;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.LoanMonthlyBalance;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(LoanMonthlyBalance.class)
@Setter
@Getter
public class LoanMonthlyBalanceSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "LoanMonthlyBalance".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("supplierName", "s");
    map.put("applicationDep", "sd");
    map.put("wid", "w");
    map.put("stockinUid", "su");
    map.put("optUid", "su2");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：LoanMonthlyBalance/Allmonthly, LoanMonthlyBalance/WaitApply, LoanMonthlyBalance/InfullApply, LoanMonthlyBalance/PaidOff
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 供应商
   */
  private Long supplierName;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierNameEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierNameNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierNameGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierNameGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierNameLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierNameLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierNameContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierNameNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierNameStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierNameEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierNameIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierNameIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierNameSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierNameSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierNameSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierNameSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierNameSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierNameSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierNameSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierNameSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierNameSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierNameSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierNameSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierNameSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierNameInList;

  /**
   * 结算描述(模糊搜索)
   */
  private String describe;

  /**
   * 结算描述 比较(eq)
   */
  private String describeEq;
  /**
   * 结算描述 比较(neq)
   */
  private String describeNeq;
  /**
   * 结算描述 比较(gt)
   */
  private String describeGt;
  /**
   * 结算描述 比较(gte)
   */
  private String describeGte;
  /**
   * 结算描述 比较(lt)
   */
  private String describeLt;
  /**
   * 结算描述 比较(lte)
   */
  private String describeLte;
  /**
   * 结算描述 比较(contains)
   */
  private String describeContains;
  /**
   * 结算描述 比较(notcontains)
   */
  private String describeNotcontains;
  /**
   * 结算描述 比较(startswith)
   */
  private String describeStartswith;
  /**
   * 结算描述 比较(endswith)
   */
  private String describeEndswith;
  /**
   * 结算描述 比较(isnull)
   */
  private Boolean describeIsnull;
  /**
   * 结算描述 比较(isnotnull)
   */
  private Boolean describeIsnotnull;

  /**
   * 结算描述(精确搜索)
   */
  private List<String> describeInList;

  /**
   * 采购单号(模糊搜索)
   */
  private String purchaseOrderCode;

  /**
   * 采购单号 比较(eq)
   */
  private String purchaseOrderCodeEq;
  /**
   * 采购单号 比较(neq)
   */
  private String purchaseOrderCodeNeq;
  /**
   * 采购单号 比较(gt)
   */
  private String purchaseOrderCodeGt;
  /**
   * 采购单号 比较(gte)
   */
  private String purchaseOrderCodeGte;
  /**
   * 采购单号 比较(lt)
   */
  private String purchaseOrderCodeLt;
  /**
   * 采购单号 比较(lte)
   */
  private String purchaseOrderCodeLte;
  /**
   * 采购单号 比较(contains)
   */
  private String purchaseOrderCodeContains;
  /**
   * 采购单号 比较(notcontains)
   */
  private String purchaseOrderCodeNotcontains;
  /**
   * 采购单号 比较(startswith)
   */
  private String purchaseOrderCodeStartswith;
  /**
   * 采购单号 比较(endswith)
   */
  private String purchaseOrderCodeEndswith;
  /**
   * 采购单号 比较(isnull)
   */
  private Boolean purchaseOrderCodeIsnull;
  /**
   * 采购单号 比较(isnotnull)
   */
  private Boolean purchaseOrderCodeIsnotnull;

  /**
   * 采购单号(精确搜索)
   */
  private List<String> purchaseOrderCodeInList;

  /**
   * 采购方
   */
  private Long applicationDep;

  /**
   * 采购方 比较(eq)
   */
  private Long applicationDepEq;
  /**
   * 采购方 比较(neq)
   */
  private Long applicationDepNeq;
  /**
   * 采购方 比较(gt)
   */
  private Long applicationDepGt;
  /**
   * 采购方 比较(gte)
   */
  private Long applicationDepGte;
  /**
   * 采购方 比较(lt)
   */
  private Long applicationDepLt;
  /**
   * 采购方 比较(lte)
   */
  private Long applicationDepLte;
  /**
   * 采购方 比较(contains)
   */
  private Long applicationDepContains;
  /**
   * 采购方 比较(notcontains)
   */
  private Long applicationDepNotcontains;
  /**
   * 采购方 比较(startswith)
   */
  private Long applicationDepStartswith;
  /**
   * 采购方 比较(endswith)
   */
  private Long applicationDepEndswith;
  /**
   * 采购方 比较(isnull)
   */
  private Boolean applicationDepIsnull;
  /**
   * 采购方 比较(isnotnull)
   */
  private Boolean applicationDepIsnotnull;
  /**
   * 采购方的部门名称 比较(eq)
   */
  private String applicationDepNameEq;
  /**
   * 采购方的部门名称 比较(neq)
   */
  private String applicationDepNameNeq;
  /**
   * 采购方的部门名称 比较(gt)
   */
  private String applicationDepNameGt;
  /**
   * 采购方的部门名称 比较(gte)
   */
  private String applicationDepNameGte;
  /**
   * 采购方的部门名称 比较(lt)
   */
  private String applicationDepNameLt;
  /**
   * 采购方的部门名称 比较(lte)
   */
  private String applicationDepNameLte;
  /**
   * 采购方的部门名称 比较(contains)
   */
  private String applicationDepNameContains;
  /**
   * 采购方的部门名称 比较(notcontains)
   */
  private String applicationDepNameNotcontains;
  /**
   * 采购方的部门名称 比较(startswith)
   */
  private String applicationDepNameStartswith;
  /**
   * 采购方的部门名称 比较(endswith)
   */
  private String applicationDepNameEndswith;
  /**
   * 采购方的部门名称 比较(isnull)
   */
  private Boolean applicationDepNameIsnull;
  /**
   * 采购方的部门名称 比较(isnotnull)
   */
  private Boolean applicationDepNameIsnotnull;

  /**
   * 采购方(范围搜索)
   */
  private List<Long> applicationDepInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 入库单号(模糊搜索)
   */
  private String orderSn;

  /**
   * 入库单号 比较(eq)
   */
  private String orderSnEq;
  /**
   * 入库单号 比较(neq)
   */
  private String orderSnNeq;
  /**
   * 入库单号 比较(gt)
   */
  private String orderSnGt;
  /**
   * 入库单号 比较(gte)
   */
  private String orderSnGte;
  /**
   * 入库单号 比较(lt)
   */
  private String orderSnLt;
  /**
   * 入库单号 比较(lte)
   */
  private String orderSnLte;
  /**
   * 入库单号 比较(contains)
   */
  private String orderSnContains;
  /**
   * 入库单号 比较(notcontains)
   */
  private String orderSnNotcontains;
  /**
   * 入库单号 比较(startswith)
   */
  private String orderSnStartswith;
  /**
   * 入库单号 比较(endswith)
   */
  private String orderSnEndswith;
  /**
   * 入库单号 比较(isnull)
   */
  private Boolean orderSnIsnull;
  /**
   * 入库单号 比较(isnotnull)
   */
  private Boolean orderSnIsnotnull;

  /**
   * 入库单号(精确搜索)
   */
  private List<String> orderSnInList;

  /**
   * 仓库
   */
  private Long wid;

  /**
   * 仓库 比较(eq)
   */
  private Long widEq;
  /**
   * 仓库 比较(neq)
   */
  private Long widNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long widGt;
  /**
   * 仓库 比较(gte)
   */
  private Long widGte;
  /**
   * 仓库 比较(lt)
   */
  private Long widLt;
  /**
   * 仓库 比较(lte)
   */
  private Long widLte;
  /**
   * 仓库 比较(contains)
   */
  private Long widContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long widNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long widStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long widEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean widIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean widIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String widNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String widNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String widNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String widNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String widNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String widNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String widNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String widNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String widNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String widNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean widNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean widNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> widInList;

  /**
   * 最早入库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date warehousingDateStart;

  /**
   * 最晚入库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date warehousingDateEnd;

  /**
   * 入库时间 比较(eq)
   */
  private Date warehousingDateEq;
  /**
   * 入库时间 比较(neq)
   */
  private Date warehousingDateNeq;
  /**
   * 入库时间 比较(gt)
   */
  private Date warehousingDateGt;
  /**
   * 入库时间 比较(gte)
   */
  private Date warehousingDateGte;
  /**
   * 入库时间 比较(lt)
   */
  private Date warehousingDateLt;
  /**
   * 入库时间 比较(lte)
   */
  private Date warehousingDateLte;
  /**
   * 入库时间 比较(contains)
   */
  private Date warehousingDateContains;
  /**
   * 入库时间 比较(notcontains)
   */
  private Date warehousingDateNotcontains;
  /**
   * 入库时间 比较(startswith)
   */
  private Date warehousingDateStartswith;
  /**
   * 入库时间 比较(endswith)
   */
  private Date warehousingDateEndswith;
  /**
   * 入库时间 比较(isnull)
   */
  private Boolean warehousingDateIsnull;
  /**
   * 入库时间 比较(isnotnull)
   */
  private Boolean warehousingDateIsnotnull;

  /**
   * 最早结算账期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date closingPeriodStart;

  /**
   * 最晚结算账期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date closingPeriodEnd;

  /**
   * 结算账期 比较(eq)
   */
  private Date closingPeriodEq;
  /**
   * 结算账期 比较(neq)
   */
  private Date closingPeriodNeq;
  /**
   * 结算账期 比较(gt)
   */
  private Date closingPeriodGt;
  /**
   * 结算账期 比较(gte)
   */
  private Date closingPeriodGte;
  /**
   * 结算账期 比较(lt)
   */
  private Date closingPeriodLt;
  /**
   * 结算账期 比较(lte)
   */
  private Date closingPeriodLte;
  /**
   * 结算账期 比较(contains)
   */
  private Date closingPeriodContains;
  /**
   * 结算账期 比较(notcontains)
   */
  private Date closingPeriodNotcontains;
  /**
   * 结算账期 比较(startswith)
   */
  private Date closingPeriodStartswith;
  /**
   * 结算账期 比较(endswith)
   */
  private Date closingPeriodEndswith;
  /**
   * 结算账期 比较(isnull)
   */
  private Boolean closingPeriodIsnull;
  /**
   * 结算账期 比较(isnotnull)
   */
  private Boolean closingPeriodIsnotnull;

  /**
   * 最早应付款日
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date dueDateStart;

  /**
   * 最晚应付款日
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date dueDateEnd;

  /**
   * 应付款日 比较(eq)
   */
  private Date dueDateEq;
  /**
   * 应付款日 比较(neq)
   */
  private Date dueDateNeq;
  /**
   * 应付款日 比较(gt)
   */
  private Date dueDateGt;
  /**
   * 应付款日 比较(gte)
   */
  private Date dueDateGte;
  /**
   * 应付款日 比较(lt)
   */
  private Date dueDateLt;
  /**
   * 应付款日 比较(lte)
   */
  private Date dueDateLte;
  /**
   * 应付款日 比较(contains)
   */
  private Date dueDateContains;
  /**
   * 应付款日 比较(notcontains)
   */
  private Date dueDateNotcontains;
  /**
   * 应付款日 比较(startswith)
   */
  private Date dueDateStartswith;
  /**
   * 应付款日 比较(endswith)
   */
  private Date dueDateEndswith;
  /**
   * 应付款日 比较(isnull)
   */
  private Boolean dueDateIsnull;
  /**
   * 应付款日 比较(isnotnull)
   */
  private Boolean dueDateIsnotnull;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 预付比例
   */
  private java.math.BigDecimal budgetRatio;

  /**
   * 最小预付比例
   */
  private java.math.BigDecimal budgetRatioMin;

  /**
   * 最大预付比例
   */
  private java.math.BigDecimal budgetRatioMax;

  /**
   * 预付比例 比较(eq)
   */
  private java.math.BigDecimal budgetRatioEq;
  /**
   * 预付比例 比较(neq)
   */
  private java.math.BigDecimal budgetRatioNeq;
  /**
   * 预付比例 比较(gt)
   */
  private java.math.BigDecimal budgetRatioGt;
  /**
   * 预付比例 比较(gte)
   */
  private java.math.BigDecimal budgetRatioGte;
  /**
   * 预付比例 比较(lt)
   */
  private java.math.BigDecimal budgetRatioLt;
  /**
   * 预付比例 比较(lte)
   */
  private java.math.BigDecimal budgetRatioLte;
  /**
   * 预付比例 比较(contains)
   */
  private java.math.BigDecimal budgetRatioContains;
  /**
   * 预付比例 比较(notcontains)
   */
  private java.math.BigDecimal budgetRatioNotcontains;
  /**
   * 预付比例 比较(startswith)
   */
  private java.math.BigDecimal budgetRatioStartswith;
  /**
   * 预付比例 比较(endswith)
   */
  private java.math.BigDecimal budgetRatioEndswith;
  /**
   * 预付比例 比较(isnull)
   */
  private Boolean budgetRatioIsnull;
  /**
   * 预付比例 比较(isnotnull)
   */
  private Boolean budgetRatioIsnotnull;

  /**
   * 最早预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeStart;

  /**
   * 最晚预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeEnd;

  /**
   * 预计付款时间 比较(eq)
   */
  private Date predictFkTimeEq;
  /**
   * 预计付款时间 比较(neq)
   */
  private Date predictFkTimeNeq;
  /**
   * 预计付款时间 比较(gt)
   */
  private Date predictFkTimeGt;
  /**
   * 预计付款时间 比较(gte)
   */
  private Date predictFkTimeGte;
  /**
   * 预计付款时间 比较(lt)
   */
  private Date predictFkTimeLt;
  /**
   * 预计付款时间 比较(lte)
   */
  private Date predictFkTimeLte;
  /**
   * 预计付款时间 比较(contains)
   */
  private Date predictFkTimeContains;
  /**
   * 预计付款时间 比较(notcontains)
   */
  private Date predictFkTimeNotcontains;
  /**
   * 预计付款时间 比较(startswith)
   */
  private Date predictFkTimeStartswith;
  /**
   * 预计付款时间 比较(endswith)
   */
  private Date predictFkTimeEndswith;
  /**
   * 预计付款时间 比较(isnull)
   */
  private Boolean predictFkTimeIsnull;
  /**
   * 预计付款时间 比较(isnotnull)
   */
  private Boolean predictFkTimeIsnotnull;

  /**
   * 支付方式
   */
  private String payType;

  /**
   * 支付方式 比较(eq)
   */
  private String payTypeEq;
  /**
   * 支付方式 比较(neq)
   */
  private String payTypeNeq;
  /**
   * 支付方式 比较(gt)
   */
  private String payTypeGt;
  /**
   * 支付方式 比较(gte)
   */
  private String payTypeGte;
  /**
   * 支付方式 比较(lt)
   */
  private String payTypeLt;
  /**
   * 支付方式 比较(lte)
   */
  private String payTypeLte;
  /**
   * 支付方式 比较(contains)
   */
  private String payTypeContains;
  /**
   * 支付方式 比较(notcontains)
   */
  private String payTypeNotcontains;
  /**
   * 支付方式 比较(startswith)
   */
  private String payTypeStartswith;
  /**
   * 支付方式 比较(endswith)
   */
  private String payTypeEndswith;
  /**
   * 支付方式 比较(isnull)
   */
  private Boolean payTypeIsnull;
  /**
   * 支付方式 比较(isnotnull)
   */
  private Boolean payTypeIsnotnull;

  /**
   * 支付方式(精确搜索)
   */
  private List<String> payTypeInList;

  /**
   * 户名(模糊搜索)
   */
  private String userName;

  /**
   * 户名 比较(eq)
   */
  private String userNameEq;
  /**
   * 户名 比较(neq)
   */
  private String userNameNeq;
  /**
   * 户名 比较(gt)
   */
  private String userNameGt;
  /**
   * 户名 比较(gte)
   */
  private String userNameGte;
  /**
   * 户名 比较(lt)
   */
  private String userNameLt;
  /**
   * 户名 比较(lte)
   */
  private String userNameLte;
  /**
   * 户名 比较(contains)
   */
  private String userNameContains;
  /**
   * 户名 比较(notcontains)
   */
  private String userNameNotcontains;
  /**
   * 户名 比较(startswith)
   */
  private String userNameStartswith;
  /**
   * 户名 比较(endswith)
   */
  private String userNameEndswith;
  /**
   * 户名 比较(isnull)
   */
  private Boolean userNameIsnull;
  /**
   * 户名 比较(isnotnull)
   */
  private Boolean userNameIsnotnull;

  /**
   * 户名(精确搜索)
   */
  private List<String> userNameInList;

  /**
   * 开户行(模糊搜索)
   */
  private String bankOfDeposit;

  /**
   * 开户行 比较(eq)
   */
  private String bankOfDepositEq;
  /**
   * 开户行 比较(neq)
   */
  private String bankOfDepositNeq;
  /**
   * 开户行 比较(gt)
   */
  private String bankOfDepositGt;
  /**
   * 开户行 比较(gte)
   */
  private String bankOfDepositGte;
  /**
   * 开户行 比较(lt)
   */
  private String bankOfDepositLt;
  /**
   * 开户行 比较(lte)
   */
  private String bankOfDepositLte;
  /**
   * 开户行 比较(contains)
   */
  private String bankOfDepositContains;
  /**
   * 开户行 比较(notcontains)
   */
  private String bankOfDepositNotcontains;
  /**
   * 开户行 比较(startswith)
   */
  private String bankOfDepositStartswith;
  /**
   * 开户行 比较(endswith)
   */
  private String bankOfDepositEndswith;
  /**
   * 开户行 比较(isnull)
   */
  private Boolean bankOfDepositIsnull;
  /**
   * 开户行 比较(isnotnull)
   */
  private Boolean bankOfDepositIsnotnull;

  /**
   * 开户行(精确搜索)
   */
  private List<String> bankOfDepositInList;

  /**
   * 账号(模糊搜索)
   */
  private String account;

  /**
   * 账号 比较(eq)
   */
  private String accountEq;
  /**
   * 账号 比较(neq)
   */
  private String accountNeq;
  /**
   * 账号 比较(gt)
   */
  private String accountGt;
  /**
   * 账号 比较(gte)
   */
  private String accountGte;
  /**
   * 账号 比较(lt)
   */
  private String accountLt;
  /**
   * 账号 比较(lte)
   */
  private String accountLte;
  /**
   * 账号 比较(contains)
   */
  private String accountContains;
  /**
   * 账号 比较(notcontains)
   */
  private String accountNotcontains;
  /**
   * 账号 比较(startswith)
   */
  private String accountStartswith;
  /**
   * 账号 比较(endswith)
   */
  private String accountEndswith;
  /**
   * 账号 比较(isnull)
   */
  private Boolean accountIsnull;
  /**
   * 账号 比较(isnotnull)
   */
  private Boolean accountIsnotnull;

  /**
   * 账号(精确搜索)
   */
  private List<String> accountInList;

  /**
   * 付款币种
   */
  private String currency;

  /**
   * 付款币种 比较(eq)
   */
  private String currencyEq;
  /**
   * 付款币种 比较(neq)
   */
  private String currencyNeq;
  /**
   * 付款币种 比较(gt)
   */
  private String currencyGt;
  /**
   * 付款币种 比较(gte)
   */
  private String currencyGte;
  /**
   * 付款币种 比较(lt)
   */
  private String currencyLt;
  /**
   * 付款币种 比较(lte)
   */
  private String currencyLte;
  /**
   * 付款币种 比较(contains)
   */
  private String currencyContains;
  /**
   * 付款币种 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 付款币种 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 付款币种 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 付款币种 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 付款币种 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 付款币种(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 请款维度
   */
  private String withdrawDimension;

  /**
   * 请款维度 比较(eq)
   */
  private String withdrawDimensionEq;
  /**
   * 请款维度 比较(neq)
   */
  private String withdrawDimensionNeq;
  /**
   * 请款维度 比较(gt)
   */
  private String withdrawDimensionGt;
  /**
   * 请款维度 比较(gte)
   */
  private String withdrawDimensionGte;
  /**
   * 请款维度 比较(lt)
   */
  private String withdrawDimensionLt;
  /**
   * 请款维度 比较(lte)
   */
  private String withdrawDimensionLte;
  /**
   * 请款维度 比较(contains)
   */
  private String withdrawDimensionContains;
  /**
   * 请款维度 比较(notcontains)
   */
  private String withdrawDimensionNotcontains;
  /**
   * 请款维度 比较(startswith)
   */
  private String withdrawDimensionStartswith;
  /**
   * 请款维度 比较(endswith)
   */
  private String withdrawDimensionEndswith;
  /**
   * 请款维度 比较(isnull)
   */
  private Boolean withdrawDimensionIsnull;
  /**
   * 请款维度 比较(isnotnull)
   */
  private Boolean withdrawDimensionIsnotnull;

  /**
   * 请款维度(精确搜索)
   */
  private List<String> withdrawDimensionInList;

  /**
   * 采购量
   */
  private Integer purchaseQuantity;

  /**
   * 最小采购量
   */
  private Integer purchaseQuantityMin;

  /**
   * 最大采购量
   */
  private Integer purchaseQuantityMax;

  /**
   * 采购量 比较(eq)
   */
  private Integer purchaseQuantityEq;
  /**
   * 采购量 比较(neq)
   */
  private Integer purchaseQuantityNeq;
  /**
   * 采购量 比较(gt)
   */
  private Integer purchaseQuantityGt;
  /**
   * 采购量 比较(gte)
   */
  private Integer purchaseQuantityGte;
  /**
   * 采购量 比较(lt)
   */
  private Integer purchaseQuantityLt;
  /**
   * 采购量 比较(lte)
   */
  private Integer purchaseQuantityLte;
  /**
   * 采购量 比较(contains)
   */
  private Integer purchaseQuantityContains;
  /**
   * 采购量 比较(notcontains)
   */
  private Integer purchaseQuantityNotcontains;
  /**
   * 采购量 比较(startswith)
   */
  private Integer purchaseQuantityStartswith;
  /**
   * 采购量 比较(endswith)
   */
  private Integer purchaseQuantityEndswith;
  /**
   * 采购量 比较(isnull)
   */
  private Boolean purchaseQuantityIsnull;
  /**
   * 采购量 比较(isnotnull)
   */
  private Boolean purchaseQuantityIsnotnull;

  /**
   * 入库量
   */
  private Integer totalNum;

  /**
   * 最小入库量
   */
  private Integer totalNumMin;

  /**
   * 最大入库量
   */
  private Integer totalNumMax;

  /**
   * 入库量 比较(eq)
   */
  private Integer totalNumEq;
  /**
   * 入库量 比较(neq)
   */
  private Integer totalNumNeq;
  /**
   * 入库量 比较(gt)
   */
  private Integer totalNumGt;
  /**
   * 入库量 比较(gte)
   */
  private Integer totalNumGte;
  /**
   * 入库量 比较(lt)
   */
  private Integer totalNumLt;
  /**
   * 入库量 比较(lte)
   */
  private Integer totalNumLte;
  /**
   * 入库量 比较(contains)
   */
  private Integer totalNumContains;
  /**
   * 入库量 比较(notcontains)
   */
  private Integer totalNumNotcontains;
  /**
   * 入库量 比较(startswith)
   */
  private Integer totalNumStartswith;
  /**
   * 入库量 比较(endswith)
   */
  private Integer totalNumEndswith;
  /**
   * 入库量 比较(isnull)
   */
  private Boolean totalNumIsnull;
  /**
   * 入库量 比较(isnotnull)
   */
  private Boolean totalNumIsnotnull;

  /**
   * 采购金额
   */
  private java.math.BigDecimal purchaseMoney;

  /**
   * 最小采购金额
   */
  private java.math.BigDecimal purchaseMoneyMin;

  /**
   * 最大采购金额
   */
  private java.math.BigDecimal purchaseMoneyMax;

  /**
   * 采购金额 比较(eq)
   */
  private java.math.BigDecimal purchaseMoneyEq;
  /**
   * 采购金额 比较(neq)
   */
  private java.math.BigDecimal purchaseMoneyNeq;
  /**
   * 采购金额 比较(gt)
   */
  private java.math.BigDecimal purchaseMoneyGt;
  /**
   * 采购金额 比较(gte)
   */
  private java.math.BigDecimal purchaseMoneyGte;
  /**
   * 采购金额 比较(lt)
   */
  private java.math.BigDecimal purchaseMoneyLt;
  /**
   * 采购金额 比较(lte)
   */
  private java.math.BigDecimal purchaseMoneyLte;
  /**
   * 采购金额 比较(contains)
   */
  private java.math.BigDecimal purchaseMoneyContains;
  /**
   * 采购金额 比较(notcontains)
   */
  private java.math.BigDecimal purchaseMoneyNotcontains;
  /**
   * 采购金额 比较(startswith)
   */
  private java.math.BigDecimal purchaseMoneyStartswith;
  /**
   * 采购金额 比较(endswith)
   */
  private java.math.BigDecimal purchaseMoneyEndswith;
  /**
   * 采购金额 比较(isnull)
   */
  private Boolean purchaseMoneyIsnull;
  /**
   * 采购金额 比较(isnotnull)
   */
  private Boolean purchaseMoneyIsnotnull;

  /**
   * 到货金额
   */
  private java.math.BigDecimal aogMoney;

  /**
   * 最小到货金额
   */
  private java.math.BigDecimal aogMoneyMin;

  /**
   * 最大到货金额
   */
  private java.math.BigDecimal aogMoneyMax;

  /**
   * 到货金额 比较(eq)
   */
  private java.math.BigDecimal aogMoneyEq;
  /**
   * 到货金额 比较(neq)
   */
  private java.math.BigDecimal aogMoneyNeq;
  /**
   * 到货金额 比较(gt)
   */
  private java.math.BigDecimal aogMoneyGt;
  /**
   * 到货金额 比较(gte)
   */
  private java.math.BigDecimal aogMoneyGte;
  /**
   * 到货金额 比较(lt)
   */
  private java.math.BigDecimal aogMoneyLt;
  /**
   * 到货金额 比较(lte)
   */
  private java.math.BigDecimal aogMoneyLte;
  /**
   * 到货金额 比较(contains)
   */
  private java.math.BigDecimal aogMoneyContains;
  /**
   * 到货金额 比较(notcontains)
   */
  private java.math.BigDecimal aogMoneyNotcontains;
  /**
   * 到货金额 比较(startswith)
   */
  private java.math.BigDecimal aogMoneyStartswith;
  /**
   * 到货金额 比较(endswith)
   */
  private java.math.BigDecimal aogMoneyEndswith;
  /**
   * 到货金额 比较(isnull)
   */
  private Boolean aogMoneyIsnull;
  /**
   * 到货金额 比较(isnotnull)
   */
  private Boolean aogMoneyIsnotnull;

  /**
   * 请款金额
   */
  private java.math.BigDecimal qkMoney;

  /**
   * 最小请款金额
   */
  private java.math.BigDecimal qkMoneyMin;

  /**
   * 最大请款金额
   */
  private java.math.BigDecimal qkMoneyMax;

  /**
   * 请款金额 比较(eq)
   */
  private java.math.BigDecimal qkMoneyEq;
  /**
   * 请款金额 比较(neq)
   */
  private java.math.BigDecimal qkMoneyNeq;
  /**
   * 请款金额 比较(gt)
   */
  private java.math.BigDecimal qkMoneyGt;
  /**
   * 请款金额 比较(gte)
   */
  private java.math.BigDecimal qkMoneyGte;
  /**
   * 请款金额 比较(lt)
   */
  private java.math.BigDecimal qkMoneyLt;
  /**
   * 请款金额 比较(lte)
   */
  private java.math.BigDecimal qkMoneyLte;
  /**
   * 请款金额 比较(contains)
   */
  private java.math.BigDecimal qkMoneyContains;
  /**
   * 请款金额 比较(notcontains)
   */
  private java.math.BigDecimal qkMoneyNotcontains;
  /**
   * 请款金额 比较(startswith)
   */
  private java.math.BigDecimal qkMoneyStartswith;
  /**
   * 请款金额 比较(endswith)
   */
  private java.math.BigDecimal qkMoneyEndswith;
  /**
   * 请款金额 比较(isnull)
   */
  private Boolean qkMoneyIsnull;
  /**
   * 请款金额 比较(isnotnull)
   */
  private Boolean qkMoneyIsnotnull;

  /**
   * 未申请金额
   */
  private java.math.BigDecimal notApply;

  /**
   * 最小未申请金额
   */
  private java.math.BigDecimal notApplyMin;

  /**
   * 最大未申请金额
   */
  private java.math.BigDecimal notApplyMax;

  /**
   * 未申请金额 比较(eq)
   */
  private java.math.BigDecimal notApplyEq;
  /**
   * 未申请金额 比较(neq)
   */
  private java.math.BigDecimal notApplyNeq;
  /**
   * 未申请金额 比较(gt)
   */
  private java.math.BigDecimal notApplyGt;
  /**
   * 未申请金额 比较(gte)
   */
  private java.math.BigDecimal notApplyGte;
  /**
   * 未申请金额 比较(lt)
   */
  private java.math.BigDecimal notApplyLt;
  /**
   * 未申请金额 比较(lte)
   */
  private java.math.BigDecimal notApplyLte;
  /**
   * 未申请金额 比较(contains)
   */
  private java.math.BigDecimal notApplyContains;
  /**
   * 未申请金额 比较(notcontains)
   */
  private java.math.BigDecimal notApplyNotcontains;
  /**
   * 未申请金额 比较(startswith)
   */
  private java.math.BigDecimal notApplyStartswith;
  /**
   * 未申请金额 比较(endswith)
   */
  private java.math.BigDecimal notApplyEndswith;
  /**
   * 未申请金额 比较(isnull)
   */
  private Boolean notApplyIsnull;
  /**
   * 未申请金额 比较(isnotnull)
   */
  private Boolean notApplyIsnotnull;

  /**
   * 折扣金额
   */
  private java.math.BigDecimal discountAmount;

  /**
   * 最小折扣金额
   */
  private java.math.BigDecimal discountAmountMin;

  /**
   * 最大折扣金额
   */
  private java.math.BigDecimal discountAmountMax;

  /**
   * 折扣金额 比较(eq)
   */
  private java.math.BigDecimal discountAmountEq;
  /**
   * 折扣金额 比较(neq)
   */
  private java.math.BigDecimal discountAmountNeq;
  /**
   * 折扣金额 比较(gt)
   */
  private java.math.BigDecimal discountAmountGt;
  /**
   * 折扣金额 比较(gte)
   */
  private java.math.BigDecimal discountAmountGte;
  /**
   * 折扣金额 比较(lt)
   */
  private java.math.BigDecimal discountAmountLt;
  /**
   * 折扣金额 比较(lte)
   */
  private java.math.BigDecimal discountAmountLte;
  /**
   * 折扣金额 比较(contains)
   */
  private java.math.BigDecimal discountAmountContains;
  /**
   * 折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal discountAmountNotcontains;
  /**
   * 折扣金额 比较(startswith)
   */
  private java.math.BigDecimal discountAmountStartswith;
  /**
   * 折扣金额 比较(endswith)
   */
  private java.math.BigDecimal discountAmountEndswith;
  /**
   * 折扣金额 比较(isnull)
   */
  private Boolean discountAmountIsnull;
  /**
   * 折扣金额 比较(isnotnull)
   */
  private Boolean discountAmountIsnotnull;

  /**
   * 请款单号(模糊搜索)
   */
  private String qkSn;

  /**
   * 请款单号 比较(eq)
   */
  private String qkSnEq;
  /**
   * 请款单号 比较(neq)
   */
  private String qkSnNeq;
  /**
   * 请款单号 比较(gt)
   */
  private String qkSnGt;
  /**
   * 请款单号 比较(gte)
   */
  private String qkSnGte;
  /**
   * 请款单号 比较(lt)
   */
  private String qkSnLt;
  /**
   * 请款单号 比较(lte)
   */
  private String qkSnLte;
  /**
   * 请款单号 比较(contains)
   */
  private String qkSnContains;
  /**
   * 请款单号 比较(notcontains)
   */
  private String qkSnNotcontains;
  /**
   * 请款单号 比较(startswith)
   */
  private String qkSnStartswith;
  /**
   * 请款单号 比较(endswith)
   */
  private String qkSnEndswith;
  /**
   * 请款单号 比较(isnull)
   */
  private Boolean qkSnIsnull;
  /**
   * 请款单号 比较(isnotnull)
   */
  private Boolean qkSnIsnotnull;

  /**
   * 请款单号(精确搜索)
   */
  private List<String> qkSnInList;

  /**
   * 入库员
   */
  private Long stockinUid;

  /**
   * 入库员 比较(eq)
   */
  private Long stockinUidEq;
  /**
   * 入库员 比较(neq)
   */
  private Long stockinUidNeq;
  /**
   * 入库员 比较(gt)
   */
  private Long stockinUidGt;
  /**
   * 入库员 比较(gte)
   */
  private Long stockinUidGte;
  /**
   * 入库员 比较(lt)
   */
  private Long stockinUidLt;
  /**
   * 入库员 比较(lte)
   */
  private Long stockinUidLte;
  /**
   * 入库员 比较(contains)
   */
  private Long stockinUidContains;
  /**
   * 入库员 比较(notcontains)
   */
  private Long stockinUidNotcontains;
  /**
   * 入库员 比较(startswith)
   */
  private Long stockinUidStartswith;
  /**
   * 入库员 比较(endswith)
   */
  private Long stockinUidEndswith;
  /**
   * 入库员 比较(isnull)
   */
  private Boolean stockinUidIsnull;
  /**
   * 入库员 比较(isnotnull)
   */
  private Boolean stockinUidIsnotnull;
  /**
   * 入库员的显示用户名 比较(eq)
   */
  private String stockinUidNameEq;
  /**
   * 入库员的显示用户名 比较(neq)
   */
  private String stockinUidNameNeq;
  /**
   * 入库员的显示用户名 比较(gt)
   */
  private String stockinUidNameGt;
  /**
   * 入库员的显示用户名 比较(gte)
   */
  private String stockinUidNameGte;
  /**
   * 入库员的显示用户名 比较(lt)
   */
  private String stockinUidNameLt;
  /**
   * 入库员的显示用户名 比较(lte)
   */
  private String stockinUidNameLte;
  /**
   * 入库员的显示用户名 比较(contains)
   */
  private String stockinUidNameContains;
  /**
   * 入库员的显示用户名 比较(notcontains)
   */
  private String stockinUidNameNotcontains;
  /**
   * 入库员的显示用户名 比较(startswith)
   */
  private String stockinUidNameStartswith;
  /**
   * 入库员的显示用户名 比较(endswith)
   */
  private String stockinUidNameEndswith;
  /**
   * 入库员的显示用户名 比较(isnull)
   */
  private Boolean stockinUidNameIsnull;
  /**
   * 入库员的显示用户名 比较(isnotnull)
   */
  private Boolean stockinUidNameIsnotnull;

  /**
   * 入库员(范围搜索)
   */
  private List<Long> stockinUidInList;

  /**
   * 采购员
   */
  private Long optUid;

  /**
   * 采购员 比较(eq)
   */
  private Long optUidEq;
  /**
   * 采购员 比较(neq)
   */
  private Long optUidNeq;
  /**
   * 采购员 比较(gt)
   */
  private Long optUidGt;
  /**
   * 采购员 比较(gte)
   */
  private Long optUidGte;
  /**
   * 采购员 比较(lt)
   */
  private Long optUidLt;
  /**
   * 采购员 比较(lte)
   */
  private Long optUidLte;
  /**
   * 采购员 比较(contains)
   */
  private Long optUidContains;
  /**
   * 采购员 比较(notcontains)
   */
  private Long optUidNotcontains;
  /**
   * 采购员 比较(startswith)
   */
  private Long optUidStartswith;
  /**
   * 采购员 比较(endswith)
   */
  private Long optUidEndswith;
  /**
   * 采购员 比较(isnull)
   */
  private Boolean optUidIsnull;
  /**
   * 采购员 比较(isnotnull)
   */
  private Boolean optUidIsnotnull;
  /**
   * 采购员的显示用户名 比较(eq)
   */
  private String optUidNameEq;
  /**
   * 采购员的显示用户名 比较(neq)
   */
  private String optUidNameNeq;
  /**
   * 采购员的显示用户名 比较(gt)
   */
  private String optUidNameGt;
  /**
   * 采购员的显示用户名 比较(gte)
   */
  private String optUidNameGte;
  /**
   * 采购员的显示用户名 比较(lt)
   */
  private String optUidNameLt;
  /**
   * 采购员的显示用户名 比较(lte)
   */
  private String optUidNameLte;
  /**
   * 采购员的显示用户名 比较(contains)
   */
  private String optUidNameContains;
  /**
   * 采购员的显示用户名 比较(notcontains)
   */
  private String optUidNameNotcontains;
  /**
   * 采购员的显示用户名 比较(startswith)
   */
  private String optUidNameStartswith;
  /**
   * 采购员的显示用户名 比较(endswith)
   */
  private String optUidNameEndswith;
  /**
   * 采购员的显示用户名 比较(isnull)
   */
  private Boolean optUidNameIsnull;
  /**
   * 采购员的显示用户名 比较(isnotnull)
   */
  private Boolean optUidNameIsnotnull;

  /**
   * 采购员(范围搜索)
   */
  private List<Long> optUidInList;

  /**
   * 是否有 附件
   */
  private Boolean files;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
